import User from '../models/user.js';
import UserBinding from '../models/bindUser.js';
import Result from '../utils/result.js';
import TokenUtil from '../utils/TokenUtil.js';

const UserService = {
    async createUser(userData) {
        try {
            const data = await User.create(userData);

            return Result.success({ id: data.id }, '注册成功').toObject();
        } catch (error) {
            return Result.error(error.message);
        }
    },

    async login(userData)  {
        try {
            let user = await User.findOne({
                where: {
                    phone: userData.phone,
                    password: userData.password,
                },
            });

            if (!user) {
                return Result.error('账号或密码错误');
            }
            console.log(user.id);
            const token = TokenUtil.generateToken({ id: user.id });
            delete user.password;

            return Result.success(
                {
                    userData:  user,
                    token: token,
                },
                '登录成功',
            );
        } catch (error) {
            return Result.error(error.message);
        }
    },

    async update(userData) {
        try {
            let user = await User.findOne({
                where: {
                    id: userData.id
                }
            });
            await user.update(userData);
            return Result.success(null, "更新用户信息成功");
        } catch (e) {
            return Result.error(e.message);
        }
    },

    async getBindingList(userId) {
        try {
            const user = await User.findByPk(userId);
            if (!user) {
                return Result.error('用户不存在');
            }
            // 查询 userId 绑定的用户列表
            const bindingList = await UserBinding.findAll({
                where: { binderId: userId }, // 查找 binderId 为当前用户的绑定关系
                include: [
                    {
                        model: User,
                        as: 'binded', // 被绑定的用户
                        attributes: ['id', 'name', 'sex', 'age','phone','bloodType'], // 选择需要的字段
                    },
                ],
            });

            // 提取绑定的用户信息
            const bindedUsers = bindingList.map((binding) => binding.binded);

            return Result.success(bindedUsers, '获取绑定列表成功');
        } catch (error) {
            return Result.error(error.message);
        }
    },
    async getBindingListPages(userId, page = 1, pageSize = 10) {
        try {
            const user = await User.findByPk(userId);
            if (!user) {
                return Result.error('用户不存在');
            }

            // 计算偏移量
            const offset = (page - 1) * pageSize;

            // 查询 userId 绑定的用户列表，支持分页
            const { count, rows: bindingList } = await UserBinding.findAndCountAll({
                where: { binderId: userId }, // 查找 binderId 为当前用户的绑定关系
                include: [
                    {
                        model: User,
                        as: 'binded', // 被绑定的用户
                        attributes: ['id', 'name', 'sex', 'age'], // 选择需要的字段
                    },
                ],
                limit: pageSize, // 每页返回的记录数
                offset: offset, // 偏移量
            });

            // 提取绑定的用户信息
            const bindedUsers = bindingList.map((binding) => binding.binded);

            return Result.success(
                {
                    total: count, // 总记录数
                    page: page, // 当前页码
                    pageSize: pageSize, // 每页记录数
                    data: bindedUsers, // 当前页的数据
                },
                '获取绑定列表成功',
            );
        } catch (error) {
            return Result.error(error.message);
        }
    },
    async binding(userId, bindedUserId , relation) {
        try {
            const user = await User.findByPk(userId);
            if (!user) {
                return Result.error('用户不存在');
            }

            const bindedUser = await User.findByPk(bindedUserId);
            if (!bindedUser) {
                return Result.error('被绑定的用户不存在');
            }

            // 检查是否已经存在绑定关系
            const existingBinding = await UserBinding.findOne({
                where: {
                    binderId: userId,
                    bindedId: bindedUserId,
                },
            });
            if (existingBinding) {
                return Result.error('该用户已经绑定过该用户');
            }

            await UserBinding.create({
                binderId: userId,
                bindedId: bindedUserId,
                relation: relation,
            });

            return Result.success({userId: userId, bindedUserId: bindedUserId}, '绑定成功');
        } catch (error) {
            return Result.error(error.message);
        }
    },
    async bindingByPhone(userId, bindedUserPhone,relation){
        try {
             const user = await User.findByPk(userId);
            if (!user) {
                return Result.error('用户不存在');
            }

            const bindedUser = await User.findOne({where:{phone:bindedUserPhone}});
            if (!bindedUser) {
                return Result.error('被绑定的用户不存在');
            }


            // 检查是否已经存在绑定关系
            const existingBinding = await UserBinding.findOne({
                where: {
                    binderId: userId,
                    bindedId: bindedUser.dataValues.id,
                },
            });
            if (existingBinding) {
                return Result.error('该用户已经绑定过该用户');
            }

            await UserBinding.create({
                binderId: userId,
                bindedId: bindedUser.dataValues.id,
                relation: relation,
            });

            return Result.success({userId: userId, bindedUserId:String(bindedUser.dataValues.id)}, '绑定成功');
        }catch (error) {
            return Result.error(error.message);
        }
    },
    async unbinding(userId, bindedUserId) {
        try {
            const user = await User.findByPk(userId);
            if (!user) {
                return Result.error('用户不存在');
            }

            const bindedUser = await User.findByPk(bindedUserId);
            if (!bindedUser) {
                return Result.error('被绑定的用户不存在');
            }
            // 检查是否存在绑定关系
            if (!existingBinding) {
                return Result.error('绑定关系不存在');
            }

            await UserBinding.destroy({
                where: {
                    binderId: userId,
                    bindedId: bindedUserId,
                },
            });
            
            return Result.success({userId: userId, bindedUserId: bindedUserId}, '解绑成功');
        }catch (error) {
            return Result.error(error.message);
        }
    },

    async getUserIdByPhone(phone) {
        try {
            const user = await User.findOne({ where: { phone: phone } });
            if (!user) {
                return Result.error('用户不存在');
            }
            return Result.success(user.id, '获取用户ID成功');
        } catch (error) {
            return Result.error(error.message);
        }
    },
};

export default UserService;
